// 引入所需依赖
import axios from 'axios';
import { ElMessage } from 'element-plus';
import store from '@/store';
import { getToken } from '@/utils/auth';

// ======= API路径前缀配置（核心配置） =======
// 这些配置会影响所有API请求的路径前缀
// const API_CONFIG = {
//   // Auth服务基础URL
//   AUTH_BASE_URL: 'http://localhost:8083/api/auth',
  
//   // Neo4j服务基础URL
//   NEO4J_BASE_URL: 'http://localhost:8082/api/neo4j',
  
//   // 请求超时时间(毫秒)
//   TIMEOUT: 30000
// };

const API_CONFIG = {
  AUTH_BASE_URL: '/api/auth',
  NEO4J_BASE_URL: '/api/neo4j',
  TIMEOUT: 30000
};

// 打印当前API配置，方便调试
console.log('API配置：', API_CONFIG);

// 创建auth服务请求实例
export const authRequest = axios.create({
  baseURL: API_CONFIG.AUTH_BASE_URL,
  timeout: API_CONFIG.TIMEOUT
});

// 创建neo4j服务请求实例
export const neo4jRequest = axios.create({
  baseURL: API_CONFIG.NEO4J_BASE_URL,
  timeout: API_CONFIG.TIMEOUT
});

// 根据环境配置输出日志
if (process.env.NODE_ENV === 'production') {
  console.log('生产环境API配置:', {
    authBaseURL: authRequest.defaults.baseURL,
    neo4jBaseURL: neo4jRequest.defaults.baseURL
  });
} else {
  console.log('开发环境API配置:', {
    authBaseURL: authRequest.defaults.baseURL,
    neo4jBaseURL: neo4jRequest.defaults.baseURL
  });
}

// 请求拦截器 - auth服务
authRequest.interceptors.request.use(
  config => {
    if (store.getters.token) {
      config.headers['Authorization'] = `Bearer ${getToken()}`;
    }
    
    // 调试日志
    console.debug('AUTH请求:', {
      url: config.url,
      method: config.method,
      headers: config.headers,
      data: config.data
    });
    
    return config;
  },
  error => {
    console.error('AUTH请求错误:', error);
    return Promise.reject(error);
  }
);

// 请求拦截器 - neo4j服务
neo4jRequest.interceptors.request.use(
  config => {
    if (store.getters.token) {
      config.headers['Authorization'] = `Bearer ${getToken()}`;
    }
    
    // 调试日志
    console.debug('NEO4J请求:', {
      url: config.url,
      method: config.method,
      headers: config.headers,
      data: config.data
    });
    
    return config;
  },
  error => {
    console.error('NEO4J请求错误:', error);
    return Promise.reject(error);
  }
);

// 统一的响应处理函数
const handleResponse = (response) => {
  // 添加更多调试日志
  console.log('接收到响应:', {
    url: response.config.url,
    method: response.config.method,
    status: response.status,
    headers: response.headers,
    data: response.data
  });

  // 直接返回数据，不做任何转换处理
  if (response.status >= 200 && response.status < 300) {
    // 只检查明确的业务错误码
    if (response.data && response.data.code !== undefined && response.data.code !== 200 && response.data.code !== 0) {
      const error = new Error(response.data?.msg || '未知业务错误');
      error.code = response.data?.code;
      error.data = response.data;
      console.error('接口返回业务错误:', error);
      return Promise.reject(error);
    }
    
    // 保持原始响应结构
    return response.data;
  }
  
  const error = new Error(`HTTP错误 (${response.status})`);
  error.status = response.status;
  error.data = response.data;
  console.error('HTTP错误:', error);
  return Promise.reject(error);
};

// 统一的错误处理函数
const handleError = (error) => {
  console.error('API请求失败:', error);
  
  let message = '系统繁忙，请稍后重试';
  
  if (error.response) {
    // 服务器返回了错误状态码
    if (error.response.status === 401) {
      message = '登录已过期，请重新登录';
      // 登录过期，跳转到登录页
      store.dispatch('resetToken').then(() => {
        location.href = '/login';
      });
    } else if (error.response.status === 403) {
      message = '没有权限执行此操作';
    } else if (error.response.status >= 500) {
      message = '服务器内部错误，请联系管理员';
    } else if (error.response.status === 404) {
      message = '请求的资源不存在';
    }
  } else if (error.message.includes('timeout')) {
    message = '请求超时，请检查网络连接';
  } else if (error.message.includes('Network Error')) {
    message = '网络连接异常，请检查网络设置';
  }
  
  // 显示错误消息
  ElMessage.error(message);
  
  return Promise.reject(error);
};

// 添加响应拦截器 - auth服务
authRequest.interceptors.response.use(
  response => handleResponse(response),
  error => handleError(error)
);

// 添加响应拦截器 - neo4j服务
neo4jRequest.interceptors.response.use(
  response => handleResponse(response),
  error => handleError(error)
);

// ======= API路径配置（所有API路径集中管理） =======
export const apiPaths = {
  // Auth服务相关路径 - 不需要/api/auth前缀，因为baseURL已包含
  auth: {
    login: '/signin',
    register: '/signup',
    userInfo: '/user-info',
    logout: '/logout',
    refreshToken: '/refresh-token'
  },
  
  // Admin相关路径 - 不需要/api/auth前缀，因为baseURL已包含
  admin: {
    users: '/admin/users',
    user: (id) => `/admin/users/${id}`,
    userPermissions: (id) => `/admin/users/${id}/permissions`,
    permissions: '/admin/permissions',
    roles: '/admin/roles'
  },
  
  // 公司相关API路径 - 不需要/api前缀，因为neo4jRequest的baseURL已包含
  company: {
    search: '/companies/search',
    detail: (id) => `/companies/${id}`
  },
  
  // 产品相关API路径 - 不需要/api前缀
  product: {
    search: '/products/search',
    detail: (id) => `/products/${id}`
  },
  
  // 知识图谱分析相关API路径 - 不需要/api前缀
  graphAnalysis: {
    supplyChain: '/graph-analysis/supply-chain',
    industry: '/graph-analysis/industry',
    industryAnalysis: '/graph-analysis/industry-analysis',
    companyRisks: '/graph-analysis/company-risks',
    highTechCompanies: '/graph-analysis/high-tech-companies',
    supplyChainPath: '/graph-analysis/supply-chain-path',
    companyStats: '/graph-analysis/company-stats',
    productChain: '/graph-analysis/product-chain',
    searchProducts: '/graph-analysis/search-products',
    industryComprehensive: "/graph-analysis/industry-comprehensive",
    keyMaterials: "/graph-analysis/key-materials",
    supplyChainVulnerability: "/graph-analysis/supply-chain-vulnerability",
    substituteAnalysis: "/graph-analysis/substitute-analysis"
  }
};

// 导出默认的neo4j请求实例，便于直接使用
export default neo4jRequest; 